package org.lzy.shop.cart

import android.content.Context
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.lzy.shop.database.CartDatabase
import org.lzy.shop.database.dao.CartItemDao
import org.lzy.shop.database.dao.GoodsSpecDao
import org.lzy.shop.database.entity.CartItemEntity
import org.lzy.shop.database.entity.GoodsSpecEntity
import org.lzy.shop.response.GoodsSpecResponse

class ShoppingCartManager private constructor(context: Context) {
    private val database: CartDatabase = CartDatabase.getDatabase(context)
    private val cartItemDao: CartItemDao = database.cartItemDao()
    private val goodsSpecDao: GoodsSpecDao = database.goodsSpecDao()


    companion object {
        // 单例模式
        @Volatile
        private var instance: ShoppingCartManager? = null

        fun getInstance(context: Context): ShoppingCartManager {
            if (instance == null) {
                synchronized(ShoppingCartManager::class.java) {
                    if (instance == null) {
                        instance = ShoppingCartManager(context)

                    }
                }
            }
            return instance!!
        }
    }
    init {
        // 初始化时从MMKV加载购物车数据
        //loadCartItems()
    }

    /**
     * 添加商品到购物车
     * @param cartItem 要添加的商品
     * @param quantity 要添加的数量
     * @return 是否添加成功
     */
    suspend fun addToCart(cartItem: CartItem, quantity: Int = 1): Boolean {
        return try {
            withContext(Dispatchers.IO) {
                val existingCartItems = cartItemDao.getAllCartItems()
                var found = false
                for (item in existingCartItems) {
                    val specs = goodsSpecDao.getSpecsByCartItemId(item.id)
                    if (item.goodsId == cartItem.goodsId &&
                        specs.map { it.toGoodsSpecResponse() } == cartItem.spec) {
                        // 如果已存在，更新数量
                        cartItemDao.updateQuantity(item.id, item.quantity + quantity)
                        found = true
                        break
                    }
                }

                if (!found) {
                    // 如果不存在，添加新商品
                    val cartItemEntity = CartItemEntity.fromCartItem(cartItem.copy(quantity = quantity))
                    val cartItemId = cartItemDao.insert(cartItemEntity)

                    // 添加规格信息
                    val specEntities = cartItem.spec.map {
                        GoodsSpecEntity.fromGoodsSpecResponse(it, cartItemId.toInt())
                    }
                    goodsSpecDao.insertAll(specEntities)
                }
            }
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 从购物车移除商品
     * @param position 商品在列表中的位置
     * @return 是否移除成功
     */
    suspend fun removeFromCart(position: Int): Boolean {
        return try {
            withContext(Dispatchers.IO) {
                val cartItems = cartItemDao.getAllCartItems()
                if (position >= 0 && position < cartItems.size) {
                    val cartItem = cartItems[position]
                    // 先删除关联的规格信息
                    goodsSpecDao.deleteByCartItemId(cartItem.id)
                    // 再删除购物车项
                    cartItemDao.delete(cartItem)
                }
            }
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 根据商品ID和规格移除商品
     * @param goodsId 商品ID
     * @param spec 商品规格
     * @return 是否移除成功
     */
    suspend fun removeFromCart(goodsId: Int, spec: List<GoodsSpecResponse>): Boolean {
        return try {
            withContext(Dispatchers.IO) {
                val cartItems = cartItemDao.getAllCartItems()
                for (cartItem in cartItems) {
                    val specs = goodsSpecDao.getSpecsByCartItemId(cartItem.id)
                    if (cartItem.goodsId == goodsId &&
                        specs.map { it.toGoodsSpecResponse() } == spec) {
                        goodsSpecDao.deleteByCartItemId(cartItem.id)
                        cartItemDao.delete(cartItem)
                        break
                    }
                }
            }
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 更新购物车商品数量
     * @param position 商品在列表中的位置
     * @param quantity 新的数量
     * @return 是否更新成功
     */
    suspend fun updateCartItemQuantity(position: Int, quantity: Int): Boolean {
        return try {
            withContext(Dispatchers.IO) {
                val cartItems = cartItemDao.getAllCartItems()
                if (position >= 0 && position < cartItems.size && quantity > 0) {
                    cartItemDao.updateQuantity(cartItems[position].id, quantity)
                }
            }
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 更新商品选中状态
     * @param position 商品在列表中的位置
     * @param isSelected 是否选中
     * @return 是否更新成功
     */
    suspend fun updateItemSelectedState(position: Int, isSelected: Boolean): Boolean {
        return try {
            withContext(Dispatchers.IO) {
                val cartItems = cartItemDao.getAllCartItems()
                if (position >= 0 && position < cartItems.size) {
                    cartItemDao.updateSelectedStatus(cartItems[position].id, isSelected)
                }
            }
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 全选/取消全选
     * @param isSelected 是否全选
     */
    suspend fun selectAllItems(isSelected: Boolean): Boolean {
        return try {
            withContext(Dispatchers.IO) {
                cartItemDao.updateAllSelectedStatus(isSelected)
            }
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 获取所有购物车商品
     * @return 购物车商品列表
     */
  suspend fun getCartItems(): List<CartItem> {
        return withContext(Dispatchers.IO) {
            val cartItemEntities = cartItemDao.getAllCartItems()
            val cartItems = mutableListOf<CartItem>()

            for (entity in cartItemEntities) {
                val specs = goodsSpecDao.getSpecsByCartItemId(entity.id)
                cartItems.add(entity.toCartItem(specs))
            }

            cartItems
        }
    }

    /**
     * 获取选中的购物车商品
     * @return 选中的购物车商品列表
     */
  suspend  fun getSelectedCartItems(): List<CartItem> {
        return withContext(Dispatchers.IO) {
            val selectedCartItemEntities = cartItemDao.getSelectedCartItems()
            val cartItems = mutableListOf<CartItem>()

            for (entity in selectedCartItemEntities) {
                val specs = goodsSpecDao.getSpecsByCartItemId(entity.id)
                cartItems.add(entity.toCartItem(specs))
            }

            cartItems
        }
    }

    /**
     * 获取购物车商品总数
     * @return 商品总数
     */
  suspend  fun getCartItemCount(): Int {
        return withContext(Dispatchers.IO) {
            cartItemDao.getCartItemCount()
        }
    }

    /**
     * 获取选中商品的总数
     * @return 选中商品的总数
     */
  suspend  fun getSelectedItemCount(): Int {
        return withContext(Dispatchers.IO) {
            cartItemDao.getSelectedItemCount()
        }
    }

    /**
     * 计算选中商品的总金额
     * @return 选中商品的总金额
     */
    suspend fun calculateTotalPrice(): Double {
        return withContext(Dispatchers.IO) {
            val selectedCartItems = getSelectedCartItems()
            selectedCartItems.sumOf {
                val price = it.spec.firstOrNull()?.price?.toDoubleOrNull() ?: 0.0
                price * it.quantity
            }
        }
    }

    /**
     * 清空购物车
     * @return 是否清空成功
     */
  suspend  fun clearCart(): Boolean {
        return try {
            withContext(Dispatchers.IO) {
                cartItemDao.clearCart()
                // 由于设置了级联删除，规格信息会自动被删除
            }
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 检查购物车是否为空
     * @return 购物车是否为空
     */
    suspend fun isCartEmpty(): Boolean {
        return withContext(Dispatchers.IO) {
            cartItemDao.isCartEmpty()
        }
    }

    /**
     * 获取选中商品的种类数量（有多少个不同的商品被选中）
     * @return 选中商品的种类数量
     */
   suspend fun getSelectedItemTypesCount(): Int {
        return withContext(Dispatchers.IO) {
            cartItemDao.getSelectedItemTypesCount()
        }
    }

    // 表示按品牌分组的购物车数据
    data class CartItemGroup(
        // 品牌名称
        val brandName: String,
        // 该品牌下的所有商品
        val items: List<CartItem>
    )

    /**
     * 获取按品牌分组的购物车商品
     * @return 按品牌分组的购物车商品列表
     */
    suspend fun getCartItemsGroupedByBrand(): List<CartItemGroup> {
        return withContext(Dispatchers.IO) {
            val cartItems = getCartItems()
            // 使用高效的分组方式
            val groupedItems = LinkedHashMap<String, MutableList<CartItem>>()

            for (item in cartItems) {
                val brandName = extractBrandName(item.goodsName)
                if (!groupedItems.containsKey(brandName)) {
                    groupedItems[brandName] = mutableListOf()
                }
                groupedItems[brandName]?.add(item)
            }
            // 转换为CartItemGroup列表
            groupedItems.map { (brandName, items) ->
                CartItemGroup(brandName = brandName, items = items)
            }
        }
    }

    /**
     * 从商品名称中提取品牌名称
     * @param goodsName 商品名称
     * @return 提取的品牌名称
     */
    private fun extractBrandName(goodsName: String): String {
        // 优化品牌名称提取逻辑，避免复杂正则表达式，使用更简单高效的方式
        if (goodsName.isBlank()) return "其他"

        // 先尝试提取第一个空格前的内容作为品牌
        val firstSpaceIndex = goodsName.indexOf(' ')
        if (firstSpaceIndex > 0) {
            return goodsName.take(firstSpaceIndex)
        }

        // 如果没有空格，尝试提取前几个字符或直接返回
        return goodsName
    }
}